home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / JApplet.java < prev    next >
Text File  |  1998-06-30  |  24KB  |  766 lines
  1. /*
  2.  * @(#)JApplet.java    1.30 98/06/23
  3.  *
  4.  * Copyright 1997, 1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  *
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14. package com.sun.java.swing;
  15.  
  16. import java.awt.*;
  17. import java.awt.event.*;
  18. import java.applet.Applet;
  19. import java.beans.PropertyChangeListener;
  20. import java.util.Locale;
  21. import java.util.Vector;
  22. import java.io.Serializable;
  23. import com.sun.java.accessibility.*;
  24.  
  25. /**
  26.  * An extended version of java.applet.Applet that adds support for 
  27.  * interposing input and painting behavior in front of the applets
  28.  * children (see glassPane), support for special children that 
  29.  * are managed by a LayeredPane (see rootPane) and for Swing MenuBars.
  30.  * <p>
  31.  * The JApplet class is slightly incompatible with java.applet.Applet.
  32.  * JApplet contains a JRootPane as it's only child.
  33.  * The <b>contentPane</b> should be the parent of any children of the JApplet.
  34.  * This is different than java.applet.Applet, e.g. to add a child to 
  35.  * an an java.applet.Applet you'd write:
  36.  * <pre>
  37.  *       applet.add(child);
  38.  * </pre>
  39.  * However using JApplet you need to add the child to the JApplet's contentPane
  40.  * instead:
  41.  * <pre>
  42.  *       applet.getContentPane().add(child);
  43.  * </pre>
  44.  * The same is true for setting LayoutManagers, removing components,
  45.  * listing children, etc. All these methods should normally be sent to
  46.  * the contentPane() instead of the JApplet itself. The contentPane() will
  47.  * always be non-null. Attempting to set it to null will cause the JApplet
  48.  * to throw an exception. The default contentPane() will have a BorderLayout
  49.  * manager set on it. 
  50.  * <p>
  51.  * Please see the JRootPane documentation for a complete description of
  52.  * the contentPane, glassPane, and layeredPane properties.
  53.  * <p>
  54.  * For the keyboard keys used by this component in the standard Look and
  55.  * Feel (L&F) renditions, see the
  56.  * <a href="doc-files/Key-Index.html#JApplet">JApplet</a> key assignments.
  57.  * <p>
  58.  * Both Netscape Communicator and Internet Explorer 4.0 unconditionally
  59.  * print an error message to the Java console when an applet attempts
  60.  * to access the AWT system event queue.  Swing applets do this once,
  61.  * to check if access is permitted.  To prevent the warning message in
  62.  * a production applet one can set a client property called 
  63.  * "defeatSystemEventQueueCheck" on the JApplets RootPane to any 
  64.  * non null value, e.g:
  65.  * <pre>
  66.  * JRootPane rp = myJApplet.getRootPane();
  67.  * rp.putClientProperty("defeatSystemEventQueueCheck", Boolean.TRUE);
  68.  * </pre>
  69.  * We hope that future versions of the browsers will not have this 
  70.  * limitation and we'll be able to retire this hack.
  71.  * <p>
  72.  * Warning: serialized objects of this class will not be compatible with
  73.  * future swing releases.  The current serialization support is appropriate 
  74.  * for short term storage or RMI between Swing1.0 applications.  It will
  75.  * not be possible to load serialized Swing1.0 objects with future releases
  76.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  77.  * baseline for the serialized form of Swing objects.
  78.  *
  79.  * @beaninfo
  80.  *      attribute: isContainer true
  81.  *      attribute: containerDelegate getContentPane
  82.  *    description: Swing's Applet subclass.
  83.  *
  84.  * @version 1.30 06/23/98
  85.  * @author Arnaud Weber
  86.  */
  87. public class JApplet extends Applet implements Accessible, RootPaneContainer 
  88. {
  89.     /**
  90.      * @see #getRootPane
  91.      * @see #setRootPane
  92.      */
  93.     protected JRootPane rootPane;
  94.  
  95.     /**
  96.      * @see #isRootPaneCheckingEnabled
  97.      * @see #setRootPaneCheckingEnabled
  98.      */
  99.     protected boolean rootPaneCheckingEnabled = false;
  100.  
  101.     /**
  102.      * Creates a swing applet instance.
  103.      */
  104.     public JApplet() {
  105.         super();
  106.     // Check the timerQ and restart if necessary.
  107.     TimerQueue q = TimerQueue.sharedInstance();
  108.     if(q != null) {
  109.         synchronized(q) {
  110.         if(!q.running)
  111.             q.start();
  112.         }
  113.     }
  114.         setLayout(new BorderLayout());
  115.         setRootPane(createRootPane());
  116.         setRootPaneCheckingEnabled(true);
  117.     }
  118.  
  119.  
  120.     /** Called by the constructor methods to create the default rootPane. */
  121.     protected JRootPane createRootPane() {
  122.         return new JRootPane();
  123.     }
  124.     
  125.     protected void processKeyEvent(KeyEvent e) {
  126.         super.processKeyEvent(e);
  127.         if(!e.isConsumed()) {
  128.             JComponent.processKeyBindingsForAllComponents(e,this,new Vector(),e.getID() == KeyEvent.KEY_PRESSED);
  129.         }
  130.     }
  131.  
  132.  
  133.     /** 
  134.      * Just calls <code>paint(g)</code>.  This method was overridden to 
  135.      * prevent an unneccessary call to clear the background.
  136.      */
  137.     public void update(Graphics g) {
  138.         paint(g);
  139.     }
  140.  
  141.  
  142.    /**
  143.     * Sets the menubar for this applet.
  144.     * @param menubar the menubar being placed in the applet
  145.     *
  146.     * @see #getJMenuBar
  147.     *
  148.     * @beaninfo
  149.     *      hidden: true
  150.     * description: The menubar for accessing pulldown menus from this applet.
  151.     */
  152.     public void setJMenuBar(JMenuBar menuBar) {
  153.         getRootPane().setMenuBar(menuBar);
  154.     }
  155.  
  156.    /**
  157.     * Returns the menubar set on this applet.
  158.     *
  159.     * @see #setJMenuBar
  160.     */
  161.     public JMenuBar getJMenuBar() {
  162.         return getRootPane().getMenuBar();
  163.     }
  164.  
  165.  
  166.     /**
  167.      * @return true if add and setLayout should be checked
  168.      * @see #addImpl
  169.      * @see #setLayout
  170.      * @see #setRootPaneCheckingEnabled
  171.      */
  172.     protected boolean isRootPaneCheckingEnabled() {
  173.         return rootPaneCheckingEnabled;
  174.     }
  175.  
  176.  
  177.     /**
  178.      * If true then calls to add() and setLayout() will cause an exception
  179.      * to be thrown.  
  180.      *
  181.      * @see #addImpl
  182.      * @see #setLayout
  183.      * @see #isRootPaneCheckingEnabled
  184.      */
  185.     protected void setRootPaneCheckingEnabled(boolean enabled) {
  186.         rootPaneCheckingEnabled = enabled;
  187.     }
  188.  
  189.  
  190.     /**
  191.      * Create an runtime exception with a message like:
  192.      * <pre>
  193.      * "Do not use JApplet.add() use JApplet.getContentPane().add() instead"
  194.      * </pre>
  195.      */
  196.     private Error createRootPaneException(String op) {
  197.         String type = getClass().getName();
  198.         return new Error(
  199.             "Do not use " + type + "." + op + "() use " 
  200.                           + type + ".getContentPane()." + op + "() instead");
  201.     }
  202.  
  203.  
  204.     /**
  205.      * By default, children may not be added directly to a this component,
  206.      * they must be added to its contentPane instead.  For example:
  207.      * <pre>
  208.      * thiComponent.getContentPane().add(child)
  209.      * </pre>
  210.      * An attempt to add to directly to this component will cause an
  211.      * runtime exception to be thrown.  Subclasses can disable this
  212.      * behavior.
  213.      * 
  214.      * @see #setRootPaneCheckingEnabled
  215.      * @exception Error if called with rootPaneChecking true
  216.      */
  217.     protected void addImpl(Component comp, Object constraints, int index) 
  218.     {
  219.         if(isRootPaneCheckingEnabled()) {
  220.             throw createRootPaneException("add");
  221.         }
  222.         else {
  223.             super.addImpl(comp, constraints, index);
  224.         }
  225.     }
  226.  
  227.  
  228.     /**
  229.      * By default the layout of this component may not be set,
  230.      * the layout of its contentPane should be set instead.  
  231.      * For example:
  232.      * <pre>
  233.      * thiComponent.getContentPane().setLayout(new BorderLayout())
  234.      * </pre>
  235.      * An attempt to set the layout of this component will cause an
  236.      * runtime exception to be thrown.  Subclasses can disable this
  237.      * behavior.
  238.      * 
  239.      * @see #setRootPaneCheckingEnabled
  240.      * @exception Error if called with rootPaneChecking true
  241.      */
  242.     public void setLayout(LayoutManager manager) {
  243.         if(isRootPaneCheckingEnabled()) {
  244.             throw createRootPaneException("setLayout");
  245.         }
  246.         else {
  247.             super.setLayout(manager);
  248.         }
  249.     }
  250.  
  251.  
  252.     /**
  253.      * Returns the rootPane object for this applet.
  254.      *
  255.      * @see #setRootPane
  256.      * @see RootPaneContainer#getRootPane
  257.      */
  258.     public JRootPane getRootPane() { 
  259.         return rootPane; 
  260.     }
  261.  
  262.  
  263.     /**
  264.      * Sets the rootPane property.  This method is called by the constructor.
  265.      * @param root the rootPane object for this applet
  266.      *
  267.      * @see #getRootPane
  268.      *
  269.      * @beaninfo
  270.      *   hidden: true
  271.      * description: the RootPane object for this applet.
  272.      */
  273.     protected void setRootPane(JRootPane root) {
  274.         if(rootPane != null) {
  275.             remove(rootPane);
  276.         }
  277.         rootPane = root;
  278.         if(rootPane != null) {
  279.             boolean checkingEnabled = isRootPaneCheckingEnabled();
  280.             try {
  281.                 setRootPaneCheckingEnabled(false);
  282.                 add(rootPane, BorderLayout.CENTER);
  283.             }
  284.             finally {
  285.                 setRootPaneCheckingEnabled(checkingEnabled);
  286.             }
  287.         }
  288.     }
  289.  
  290.  
  291.     /**
  292.      * Returns the contentPane object for this applet.
  293.      *
  294.      * @see #setContentPane
  295.      * @see RootPaneContainer#getContentPane
  296.      */
  297.     public Container getContentPane() { 
  298.         return getRootPane().getContentPane(); 
  299.     }
  300.  
  301.    /**
  302.      * Sets the contentPane property.  This method is called by the constructor.
  303.      * @param contentPane the contentPane object for this applet
  304.      *
  305.      * @exception java.awt.IllegalComponentStateException (a runtime
  306.      *            exception) if the content pane parameter is null
  307.      * @see #getContentPane
  308.      * @see RootPaneContainer#setContentPane
  309.      *
  310.      * @beaninfo
  311.      *     hidden: true
  312.      *     description: The client area of the applet where child 
  313.      *                  components are normally inserted.
  314.      */
  315.     public void setContentPane(Container contentPane) {
  316.         getRootPane().setContentPane(contentPane);
  317.     }
  318.  
  319.     /**
  320.      * Returns the layeredPane object for this applet.
  321.      *
  322.      * @exception java.awt.IllegalComponentStateException (a runtime
  323.      *            exception) if the layered pane parameter is null
  324.      * @see #setLayeredPane
  325.      * @see RootPaneContainer#getLayeredPane
  326.      */
  327.     public JLayeredPane getLayeredPane() { 
  328.         return getRootPane().getLayeredPane(); 
  329.     }
  330.  
  331.     /**
  332.      * Sets the layeredPane property.  This method is called by the constructor.
  333.      * @param layeredPane the layeredPane object for this applet
  334.      *
  335.      * @see #getLayeredPane
  336.      * @see RootPaneContainer#setLayeredPane
  337.      *
  338.      * @beaninfo
  339.      *     hidden: true
  340.      *     description: The pane which holds the various applet layers.
  341.      */
  342.     public void setLayeredPane(JLayeredPane layeredPane) {
  343.         getRootPane().setLayeredPane(layeredPane);
  344.     }
  345.  
  346.     /**
  347.      * Returns the glassPane object for this applet.
  348.      *
  349.      * @see #setGlassPane
  350.      * @see RootPaneContainer#getGlassPane
  351.      */
  352.     public Component getGlassPane() { 
  353.         return getRootPane().getGlassPane(); 
  354.     }
  355.  
  356.     /**
  357.      * Sets the glassPane property. 
  358.      * This method is called by the constructor.
  359.      * @param glassPane the glassPane object for this applet
  360.      *
  361.      * @see #getGlassPane
  362.      * @see RootPaneContainer#setGlassPane
  363.      *
  364.      * @beaninfo
  365.      *     hidden: true
  366.      *     description: A transparent pane used for menu rendering.
  367.      */
  368.     public void setGlassPane(Component glassPane) {
  369.         getRootPane().setGlassPane(glassPane);
  370.     }
  371.  
  372.  
  373.  
  374. /////////////////
  375. // Accessibility support
  376. ////////////////
  377.  
  378.     protected AccessibleContext accessibleContext = null;
  379.  
  380.     /**
  381.      * Get the AccessibleContext associated with this JApplet
  382.      *
  383.      * @return the AccessibleContext of this JApplet
  384.      */
  385.     public AccessibleContext getAccessibleContext() {
  386.         if (accessibleContext == null) {
  387.             accessibleContext = new AccessibleJApplet();
  388.         }
  389.         return accessibleContext;
  390.     }
  391.  
  392.     protected class AccessibleJApplet extends AccessibleContext
  393.         implements Serializable, AccessibleComponent {
  394.  
  395.         // AccessibleContext methods
  396.         //
  397.         /**
  398.          * Get the role of this object.
  399.          *
  400.          * @return an instance of AccessibleRole describing the role of the 
  401.          * object
  402.          * @see AccessibleRole
  403.          */
  404.         public AccessibleRole getAccessibleRole() {
  405.             return AccessibleRole.FRAME;
  406.         }
  407.  
  408.         /**
  409.          * Get the state of this object.
  410.          *
  411.          * @return an instance of AccessibleStateSet containing the current 
  412.          * state set of the object
  413.          * @see AccessibleState
  414.          */
  415.         public AccessibleStateSet getAccessibleStateSet() {
  416.             AccessibleStateSet states = SwingUtilities.getAccessibleStateSet(JApplet.this);
  417.             states.add(AccessibleState.ACTIVE);
  418.             return states;
  419.         }
  420.  
  421.         /**
  422.          * Get the Accessible parent of this object.  If the parent of this
  423.          * object implements Accessible, this method should simply return
  424.          * getParent().
  425.          *
  426.          * @return the Accessible parent of this object -- can be null if this
  427.          * object does not have an Accessible parent
  428.          */
  429.         public Accessible getAccessibleParent() {
  430.             Container parent = getParent();
  431.             if (parent instanceof Accessible) {
  432.                 return (Accessible) parent;
  433.             } else {
  434.                 return null;
  435.             }
  436.         }
  437.  
  438.         /**
  439.          * Get the index of this object in its accessible parent. 
  440.          *
  441.          * @return the index of this object in its parent; -1 if this 
  442.          * object does not have an accessible parent.
  443.          * @see #getAccessibleParent
  444.          */
  445.         public int getAccessibleIndexInParent() {
  446.             return SwingUtilities.getAccessibleIndexInParent(JApplet.this);
  447.         }
  448.  
  449.         /**
  450.          * Returns the number of accessible children in the object.  If all
  451.          * of the children of this object implement Accessible, than this
  452.          * method should return the number of children of this object.
  453.          *
  454.          * @return the number of accessible children in the object.
  455.          */
  456.         public int getAccessibleChildrenCount() {
  457.             return SwingUtilities.getAccessibleChildrenCount(JApplet.this);
  458.         }
  459.  
  460.         /**
  461.          * Return the nth Accessible child of the object.  
  462.          *
  463.          * @param i zero-based index of child
  464.          * @return the nth Accessible child of the object
  465.          */
  466.         public Accessible getAccessibleChild(int i) {
  467.             return SwingUtilities.getAccessibleChild(JApplet.this,i);
  468.         }
  469.  
  470.         /**
  471.          * Return the locale of this object.
  472.          *
  473.          * @return the locale of this object
  474.          */
  475.         public Locale getLocale() {
  476.             return JApplet.this.getLocale();
  477.         }
  478.  
  479.         /**
  480.          * Get the AccessibleComponent associated with this object if one
  481.          * exists.  Otherwise return null.
  482.          */
  483.         public AccessibleComponent getAccessibleComponent() {
  484.             return this;
  485.         }
  486.  
  487.  
  488.         // AccessibleComponent methods
  489.         //
  490.         /**
  491.          * Get the background color of this object.
  492.          *
  493.          * @return the background color, if supported, of the object; 
  494.          * otherwise, null
  495.          */
  496.         public Color getBackground() {
  497.             return JApplet.this.getBackground();
  498.         }
  499.  
  500.         /**
  501.          * Set the background color of this object.
  502.          *
  503.          * @param c the new Color for the background
  504.          */
  505.         public void setBackground(Color c) {
  506.             JApplet.this.setBackground(c);
  507.         }
  508.  
  509.         /**
  510.          * Get the foreground color of this object.
  511.          *
  512.          * @return the foreground color, if supported, of the object; 
  513.          * otherwise, null
  514.          */
  515.         public Color getForeground() {
  516.             return JApplet.this.getForeground();
  517.         }
  518.  
  519.         /**
  520.          * Set the foreground color of this object.
  521.          *
  522.          * @param c the new Color for the foreground
  523.          */
  524.         public void setForeground(Color c) {
  525.             JApplet.this.setForeground(c);
  526.         }
  527.  
  528.         /**
  529.          * Get the Cursor of this object.
  530.          *
  531.          * @return the Cursor, if supported, of the object; otherwise, null
  532.          */
  533.         public Cursor getCursor() {
  534.             return JApplet.this.getCursor();
  535.         }
  536.  
  537.         /**
  538.          * Set the Cursor of this object.
  539.          *
  540.          * @param c the new Cursor for the object
  541.          */
  542.         public void setCursor(Cursor cursor) {
  543.             JApplet.this.setCursor(cursor);
  544.         }
  545.  
  546.         /**
  547.          * Get the Font of this object.
  548.          *
  549.          * @return the Font,if supported, for the object; otherwise, null
  550.          */
  551.         public Font getFont() {
  552.             return JApplet.this.getFont();
  553.         }
  554.  
  555.         /**
  556.          * Set the Font of this object.
  557.          *
  558.          * @param f the new Font for the object
  559.          */
  560.         public void setFont(Font f) {
  561.             JApplet.this.setFont(f);
  562.         }
  563.  
  564.         /**
  565.          * Get the FontMetrics of this object.
  566.          *
  567.          * @param f the Font
  568.          * @return the FontMetrics, if supported, the object; otherwise, null
  569.          * @see getFont
  570.          */
  571.         public FontMetrics getFontMetrics(Font f) {
  572.             return JApplet.this.getFontMetrics(f);
  573.         }
  574.  
  575.         /**
  576.          * Determine if the object is enabled.
  577.          *
  578.          * @return true if object is enabled; otherwise, false
  579.          */
  580.         public boolean isEnabled() {
  581.             return JApplet.this.isEnabled();
  582.         }
  583.  
  584.         /**
  585.          * Set the enabled state of the object.
  586.          *
  587.          * @param b if true, enables this object; otherwise, disables it 
  588.          */
  589.         public void setEnabled(boolean b) {
  590.             JApplet.this.setEnabled(b);
  591.         }
  592.         
  593.         /**
  594.          * Determine if the object is visible.  Note: this means that the
  595.          * object intends to be visible; however, it may not in fact be
  596.          * showing on the screen because one of the objects that this object
  597.          * is contained by is not visible.  To determine if an object is
  598.          * showing on the screen, use isShowing().
  599.          *
  600.          * @return true if object is visible; otherwise, false
  601.          */
  602.         public boolean isVisible() {
  603.             return JApplet.this.isVisible();
  604.         }
  605.  
  606.         /**
  607.          * Set the visible state of the object.
  608.          *
  609.          * @param b if true, shows this object; otherwise, hides it 
  610.          */
  611.         public void setVisible(boolean b) {
  612.             JApplet.this.setVisible(b);
  613.         }
  614.  
  615.         /**
  616.          * Determine if the object is showing.  This is determined by checking
  617.          * the visibility of the object and ancestors of the object.  Note: 
  618.          * this will return true even if the object is obscured by another 
  619.          * (for example, it happens to be underneath a menu that was pulled 
  620.          * down).
  621.          *
  622.          * @return true if object is showing; otherwise, false
  623.          */
  624.         public boolean isShowing() {
  625.             return JApplet.this.isShowing();
  626.         }
  627.  
  628.         /** 
  629.          * Checks whether the specified point is within this object's bounds,
  630.          * where the point's x and y coordinates are defined to be relative to 
  631.          * the coordinate system of the object. 
  632.          *
  633.          * @param p the Point relative to the coordinate system of the object
  634.          * @return true if object contains Point; otherwise false
  635.          */
  636.         public boolean contains(Point p) {
  637.             return JApplet.this.contains(p);
  638.         }
  639.     
  640.         /** 
  641.          * Returns the location of the object on the screen.
  642.          *
  643.          * @return location of object on screen -- can be null if this object
  644.          * is not on the screen
  645.          */
  646.         public Point getLocationOnScreen() {
  647.             return JApplet.this.getLocationOnScreen();
  648.         }
  649.  
  650.         /** 
  651.          * Gets the location of the object relative to the parent in the form 
  652.          * of a point specifying the object's top-left corner in the screen's 
  653.          * coordinate space.
  654.          *
  655.          * @return An instance of Point representing the top-left corner of 
  656.          * the objects's bounds in the coordinate space of the screen; null if
  657.          * this object or its parent are not on the screen
  658.          */
  659.         public Point getLocation() {
  660.             return JApplet.this.getLocation();
  661.         }
  662.  
  663.         /** 
  664.          * Sets the location of the object relative to the parent.
  665.          */
  666.         public void setLocation(Point p) {
  667.             JApplet.this.setLocation(p);
  668.         }
  669.  
  670.         /** 
  671.          * Gets the bounds of this object in the form of a Rectangle object. 
  672.          * The bounds specify this object's width, height, and location
  673.          * relative to its parent. 
  674.          *
  675.          * @return A rectangle indicating this component's bounds; null if 
  676.          * this object is not on the screen.
  677.          */
  678.         public Rectangle getBounds() {
  679.             return JApplet.this.getBounds();
  680.         }
  681.  
  682.         /** 
  683.          * Sets the bounds of this object in the form of a Rectangle object. 
  684.          * The bounds specify this object's width, height, and location
  685.          * relative to its parent.
  686.          *      
  687.          * @param A rectangle indicating this component's bounds
  688.          */
  689.         public void setBounds(Rectangle r) {
  690.             JApplet.this.setBounds(r);
  691.         }
  692.  
  693.         /** 
  694.          * Returns the size of this object in the form of a Dimension object. 
  695.          * The height field of the Dimension object contains this objects's
  696.          * height, and the width field of the Dimension object contains this 
  697.          * object's width. 
  698.          *
  699.          * @return A Dimension object that indicates the size of this 
  700.          * component; null if this object is not on the screen
  701.          */
  702.         public Dimension getSize() {
  703.             return JApplet.this.getSize();
  704.         }
  705.  
  706.         /** 
  707.          * Resizes this object so that it has width width and height. 
  708.          *      
  709.          * @param d - The dimension specifying the new size of the object. 
  710.          */
  711.         public void setSize(Dimension d) {
  712.             JApplet.this.setSize(d);
  713.         }
  714.  
  715.         /**
  716.          * Returns the Accessible child, if one exists, contained at the local
  717.          * coordinate Point.
  718.          *
  719.          * @param p The point defining the top-left corner of the Accessible, 
  720.          * given in the coordinate space of the object's parent. 
  721.          * @return the Accessible, if it exists, at the specified location; 
  722.          * else null
  723.          */
  724.         public Accessible getAccessibleAt(Point p) {
  725.             return SwingUtilities.getAccessibleAt(JApplet.this,p);
  726.         }
  727.  
  728.         /**
  729.          * Returns whether this object can accept focus or not.
  730.          *
  731.          * @return true if object can accept focus; otherwise false
  732.          */
  733.         public boolean isFocusTraversable() {
  734.             return JApplet.this.isFocusTraversable();
  735.         }
  736.  
  737.         /**
  738.          * Requests focus for this object.
  739.          */
  740.         public void requestFocus() {
  741.             JApplet.this.requestFocus();
  742.         }
  743.  
  744.         /**
  745.          * Adds the specified focus listener to receive focus events from this 
  746.          * component. 
  747.          *
  748.          * @param l the focus listener
  749.          */
  750.         public void addFocusListener(FocusListener l) {
  751.             JApplet.this.addFocusListener(l);
  752.         }
  753.  
  754.         /**
  755.          * Removes the specified focus listener so it no longer receives focus 
  756.          * events from this component.
  757.          *
  758.          * @param l the focus listener
  759.          */
  760.         public void removeFocusListener(FocusListener l) {
  761.             JApplet.this.removeFocusListener(l);
  762.         }
  763.     } // inner class AccessibleJApplet
  764. }
  765.  
  766.